// 这个单元测试文件包含了以下测试用例：

// 1. BasicPushAndGet ：测试基本的任务添加和获取功能
// 2. PushTaskFirst ：测试优先任务功能
// 3. MultiThreadedExecution ：测试多线程环境下的任务队列
// 4. PushExit ：测试push_exit功能
// 5. LargeNumberOfTasks ：测试大量任务的处理
// 6. ExecutionOrder ：测试任务执行顺序
// 7. ComplexTaskType ：测试复杂任务类型

#include <gtest/gtest.h>
#include <thread>
#include <functional>
#include <atomic>
#include <chrono>
#include <vector>
#include "Thread/TaskQueue.h"

using namespace toolkit;
using namespace std;

// 定义测试用的任务类型
using Task = function<void()>;

class TaskQueueTest : public ::testing::Test {
protected:
    void SetUp() override {
    }

    void TearDown() override {
    }
};

// 测试基本的任务添加和获取功能
TEST_F(TaskQueueTest, BasicPushAndGet) {
    TaskQueue<Task> queue;
    bool task_executed = false;
    
    // 添加一个简单任务
    queue.push_task([&]() {
        task_executed = true;
    });
    
    // 验证队列大小
    EXPECT_EQ(queue.size(), 1);
    
    // 获取并执行任务
    Task task;
    EXPECT_TRUE(queue.get_task(task));
    task();
    
    // 验证任务已执行
    EXPECT_TRUE(task_executed);
    
    // 验证队列为空
    EXPECT_EQ(queue.size(), 0);
}

// 测试优先任务功能
TEST_F(TaskQueueTest, PushTaskFirst) {
    TaskQueue<Task> queue;
    vector<int> execution_order;
    
    // 添加三个普通任务
    for (int i = 1; i <= 3; i++) {
        queue.push_task([i, &execution_order]() {
            execution_order.push_back(i);
        });
    }
    
    // 添加一个优先任务
    queue.push_task_first([&execution_order]() {
        execution_order.push_back(0); // 优先任务标记为0
    });
    
    // 验证队列大小
    EXPECT_EQ(queue.size(), 4);
    
    // 依次获取并执行所有任务
    for (int i = 0; i < 4; i++) {
        Task task;
        EXPECT_TRUE(queue.get_task(task));
        task();
    }
    
    // 验证执行顺序，优先任务应该最先执行
    ASSERT_EQ(execution_order.size(), 4);
    EXPECT_EQ(execution_order[0], 0);
    EXPECT_EQ(execution_order[1], 1);
    EXPECT_EQ(execution_order[2], 2);
    EXPECT_EQ(execution_order[3], 3);
}

// 测试多线程环境下的任务队列
TEST_F(TaskQueueTest, MultiThreadedExecution) {
    TaskQueue<Task> queue;
    atomic<int> counter(0);
    const int NUM_TASKS = 1000;
    const int NUM_CONSUMERS = 4;
    
    // 生产者线程：添加任务
    thread producer([&]() {
        for (int i = 0; i < NUM_TASKS; i++) {
            queue.push_task([&counter]() {
                counter++;
            });
        }
    });
    
    // 消费者线程：获取并执行任务
    vector<thread> consumers;
    for (int i = 0; i < NUM_CONSUMERS; i++) {
        consumers.emplace_back([&queue]() {
            Task task;
            while (queue.get_task(task)) {
                task();
            }
        });
    }
    
    // 等待生产者完成
    producer.join();
    
    // 通知消费者退出
    queue.push_exit(NUM_CONSUMERS);
    
    // 等待所有消费者完成
    for (auto& t : consumers) {
        t.join();
    }
    
    // 验证所有任务都被执行
    EXPECT_EQ(counter, NUM_TASKS);
    EXPECT_EQ(queue.size(), 0);
}

// 测试push_exit功能
TEST_F(TaskQueueTest, PushExit) {
    TaskQueue<Task> queue;
    
    // 队列为空时调用get_task
    Task task;
    
    // 发送退出信号
    queue.push_exit(1);
    
    // get_task应该返回false，因为队列为空
    EXPECT_FALSE(queue.get_task(task));
}

// 测试大量任务的处理
TEST_F(TaskQueueTest, LargeNumberOfTasks) {
    TaskQueue<Task> queue;
    atomic<int> sum(0);
    const int NUM_TASKS = 10000;
    
    // 添加大量任务
    for (int i = 0; i < NUM_TASKS; i++) {
        queue.push_task([i, &sum]() {
            sum += i;
        });
    }
    
    // 验证队列大小
    EXPECT_EQ(queue.size(), NUM_TASKS);
    
    // 计算预期结果
    int expected_sum = 0;
    for (int i = 0; i < NUM_TASKS; i++) {
        expected_sum += i;
    }
    
    // 执行所有任务
    for (int i = 0; i < NUM_TASKS; i++) {
        Task task;
        EXPECT_TRUE(queue.get_task(task));
        task();
    }
    
    // 验证结果
    EXPECT_EQ(sum, expected_sum);
    EXPECT_EQ(queue.size(), 0);
}

// 测试任务执行顺序
TEST_F(TaskQueueTest, ExecutionOrder) {
    TaskQueue<Task> queue;
    vector<int> execution_order;
    const int NUM_TASKS = 100;
    
    // 添加按顺序编号的任务
    for (int i = 0; i < NUM_TASKS; i++) {
        queue.push_task([i, &execution_order]() {
            execution_order.push_back(i);
        });
    }
    
    // 执行所有任务
    for (int i = 0; i < NUM_TASKS; i++) {
        Task task;
        EXPECT_TRUE(queue.get_task(task));
        task();
    }
    
    // 验证执行顺序与添加顺序一致
    ASSERT_EQ(execution_order.size(), NUM_TASKS);
    for (int i = 0; i < NUM_TASKS; i++) {
        EXPECT_EQ(execution_order[i], i);
    }
}

// 测试复杂任务类型
TEST_F(TaskQueueTest, ComplexTaskType) {
    // 定义一个更复杂的任务类型
    struct ComplexTask {
        int id;
        function<void(int)> func;
        
        void operator()() {
            func(id);
        }
    };
    
    TaskQueue<ComplexTask> complex_queue;
    vector<int> results;
    
    // 添加复杂任务
    for (int i = 0; i < 5; i++) {
        complex_queue.push_task(ComplexTask{
            i,
            [&results](int id) {
                results.push_back(id * id);
            }
        });
    }
    
    // 执行所有任务
    for (int i = 0; i < 5; i++) {
        ComplexTask task;
        EXPECT_TRUE(complex_queue.get_task(task));
        task();
    }
    
    // 验证结果
    ASSERT_EQ(results.size(), 5);
    for (int i = 0; i < 5; i++) {
        EXPECT_EQ(results[i], i * i);
    }
}

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}